MultiLightCtrl_ImageStitching.py

Multi-Light Control, Image Splitting, and Image Stitching of Line Scan Camera

It shows how to set multi-light control parameters (the default is 2), split the image and stitch the divided images in top-bottom direction to create a new image, and save the new image to local in BMP format.

# -- coding: utf-8 --

import sys
import os
import platform
from ctypes import *


# Compatible with different operating systems to load DDL
currentsystem = platform.system()
if currentsystem == 'Windows':
    sys.path.append(os.path.join(os.getenv('MVCAM_COMMON_RUNENV'), "Samples", "Python", "MvImport"))
else:
    sys.path.append(os.path.join("..", "..", "MvImport"))
from MvCameraControl_class import *

# Compatible with input processing of Python 2.X and 3.X
if sys.version_info[0] < 3: 
    # Python 2.x
    input_func = raw_input
else: 
    # Python 3.x
    input_func = input

# Decoding Characters
def decoding_char(ctypes_char_array):
    """
    Safely decode a string from a ctypes character array.
    Compatible with Python 2.x and 3.x, as well as 32-bit and 64-bit environments.
    """
    byte_str = memoryview(ctypes_char_array).tobytes()
    
    # Truncate at the first null character
    null_index = byte_str.find(b'\x00')
    if null_index != -1:
        byte_str = byte_str[:null_index]
    
    # Attempt to decode using multiple encodings
    for encoding in ['gbk', 'utf-8', 'latin-1']:
        try:
            return byte_str.decode(encoding)
        except UnicodeDecodeError:
            continue
    
    # If all encodings fail, use a replacement strategy
    return byte_str.decode('latin-1', errors='replace')
    

exposure_num = 0  # Number of lights that support multi-light control function

HB_format_list = [
    PixelType_Gvsp_HB_Mono8,
    PixelType_Gvsp_HB_Mono10,
    PixelType_Gvsp_HB_Mono10_Packed,
    PixelType_Gvsp_HB_Mono12,
    PixelType_Gvsp_HB_Mono12_Packed,
    PixelType_Gvsp_HB_Mono16,
    PixelType_Gvsp_HB_BayerGR8,
    PixelType_Gvsp_HB_BayerRG8,
    PixelType_Gvsp_HB_BayerGB8,
    PixelType_Gvsp_HB_BayerBG8,
    PixelType_Gvsp_HB_BayerRBGG8,
    PixelType_Gvsp_HB_BayerGR10,
    PixelType_Gvsp_HB_BayerRG10,
    PixelType_Gvsp_HB_BayerGB10,
    PixelType_Gvsp_HB_BayerBG10,
    PixelType_Gvsp_HB_BayerGR12,
    PixelType_Gvsp_HB_BayerRG12,
    PixelType_Gvsp_HB_BayerGB12,
    PixelType_Gvsp_HB_BayerBG12,
    PixelType_Gvsp_HB_BayerGR10_Packed,
    PixelType_Gvsp_HB_BayerRG10_Packed,
    PixelType_Gvsp_HB_BayerGB10_Packed,
    PixelType_Gvsp_HB_BayerBG10_Packed,
    PixelType_Gvsp_HB_BayerGR12_Packed,
    PixelType_Gvsp_HB_BayerRG12_Packed,
    PixelType_Gvsp_HB_BayerGB12_Packed,
    PixelType_Gvsp_HB_BayerBG12_Packed,
    PixelType_Gvsp_HB_YUV422_Packed,
    PixelType_Gvsp_HB_YUV422_YUYV_Packed,
    PixelType_Gvsp_HB_RGB8_Packed,
    PixelType_Gvsp_HB_BGR8_Packed,
    PixelType_Gvsp_HB_RGBA8_Packed,
    PixelType_Gvsp_HB_BGRA8_Packed,
    PixelType_Gvsp_HB_RGB16_Packed,
    PixelType_Gvsp_HB_BGR16_Packed,
    PixelType_Gvsp_HB_RGBA16_Packed,
    PixelType_Gvsp_HB_BGRA16_Packed]


def print_devices_info(deviceList):
    for i in range(0, deviceList.nDeviceNum):
        mvcc_dev_info = cast(deviceList.pDeviceInfo[i], POINTER(MV_CC_DEVICE_INFO)).contents
        if mvcc_dev_info.nTLayerType == MV_GIGE_DEVICE or mvcc_dev_info.nTLayerType == MV_GENTL_GIGE_DEVICE:
            print ("\ngige device: [%d]" % i)
            strModeName = decoding_char(mvcc_dev_info.SpecialInfo.stGigEInfo.chModelName)
            print ("device model name: %s" % strModeName)
            strSerialNumber = decoding_char(mvcc_dev_info.SpecialInfo.stGigEInfo.chSerialNumber)
            print("device serial number: %s" % strSerialNumber)
            nip1 = ((mvcc_dev_info.SpecialInfo.stGigEInfo.nCurrentIp & 0xff000000) >> 24)
            nip2 = ((mvcc_dev_info.SpecialInfo.stGigEInfo.nCurrentIp & 0x00ff0000) >> 16)
            nip3 = ((mvcc_dev_info.SpecialInfo.stGigEInfo.nCurrentIp & 0x0000ff00) >> 8)
            nip4 = (mvcc_dev_info.SpecialInfo.stGigEInfo.nCurrentIp & 0x000000ff)
            print ("current ip: %d.%d.%d.%d\n" % (nip1, nip2, nip3, nip4))
        elif mvcc_dev_info.nTLayerType == MV_USB_DEVICE:
            print ("\nu3v device: [%d]" % i)
            strModeName = decoding_char(mvcc_dev_info.SpecialInfo.stUsb3VInfo.chModelName)
            print ("device model name: %s" % strModeName)

            strSerialNumber =  decoding_char(mvcc_dev_info.SpecialInfo.stUsb3VInfo.chSerialNumber)                
            print ("device serial number: %s" % strSerialNumber)
        elif mvcc_dev_info.nTLayerType == MV_GENTL_CAMERALINK_DEVICE:
            print ("\nCML device: [%d]" % i)
            strModeName = decoding_char(mvcc_dev_info.SpecialInfo.stCMLInfo.chModelName)
            print ("device model name: %s" % strModeName)

            strSerialNumber = decoding_char(mvcc_dev_info.SpecialInfo.stCMLInfo.chSerialNumber)
            print ("device serial number: %s" % strSerialNumber)
        elif mvcc_dev_info.nTLayerType == MV_GENTL_CXP_DEVICE:
            print ("\nCXP device: [%d]" % i)
            strModeName =  decoding_char(mvcc_dev_info.SpecialInfo.stCXPInfo.chModelName)
            print ("device model name: %s" % strModeName)
            
            strSerialNumber =  decoding_char(mvcc_dev_info.SpecialInfo.stCXPInfo.chSerialNumber)
            print ("device serial number: %s" % strSerialNumber)
        elif mvcc_dev_info.nTLayerType == MV_GENTL_XOF_DEVICE:
            print ("\nXoF device: [%d]" % i)
            strModeName =  decoding_char(mvcc_dev_info.SpecialInfo.stXoFInfo.chModelName)
            print ("device model name: %s" % strModeName)

            strSerialNumber =  decoding_char(mvcc_dev_info.SpecialInfo.stXoFInfo.chSerialNumber)
            print ("device serial number: %s" % strSerialNumber)

if __name__ == "__main__":

    try:
        # Initialize SDK resources
        MvCamera.MV_CC_Initialize()
        
        SDKVersion = MvCamera.MV_CC_GetSDKVersion()
        print ("SDKVersion[0x%x]" % SDKVersion)
    
        deviceList = MV_CC_DEVICE_INFO_LIST()
        tlayerType = (MV_GIGE_DEVICE | MV_USB_DEVICE | MV_GENTL_CAMERALINK_DEVICE
                      | MV_GENTL_CXP_DEVICE | MV_GENTL_XOF_DEVICE)

        # Enumerate devices
        ret = MvCamera.MV_CC_EnumDevices(tlayerType, deviceList)
        if ret != 0:
            print("enum devices fail! ret[0x%x]" % ret)
            sys.exit()

        if deviceList.nDeviceNum == 0:
            print("find no device!")
            sys.exit()

        print("Find %d devices!" % deviceList.nDeviceNum)

        print_devices_info(deviceList)

        nConnectionNum = input_func("please input the number of the device to connect:")

        if int(nConnectionNum) >= deviceList.nDeviceNum:
            print("input error!")
            sys.exit()

        str_exposure_num = input_func("please input current exposure number:")
        exposure_num = int(str_exposure_num)
        if exposure_num > MV_MAX_SPLIT_NUM or exposure_num <= 1:
            print("input error!")
            sys.exit()

        # Create a camera instance
        cam = MvCamera()

        # Select a device, and create a handle
        stDeviceList = cast(deviceList.pDeviceInfo[int(nConnectionNum)], POINTER(MV_CC_DEVICE_INFO)).contents

        ret = cam.MV_CC_CreateHandle(stDeviceList)
        if ret != 0:
            raise Exception("create handle fail! ret[0x%x]" % ret)

        # Turn on the device
        ret = cam.MV_CC_OpenDevice(MV_ACCESS_Exclusive, 0)
        if ret != 0:
            raise Exception("open device fail! ret[0x%x]" % ret)

        # Get optimal packet size (only supported by GigE devices)
        if stDeviceList.nTLayerType == MV_GIGE_DEVICE or stDeviceList.nTLayerType == MV_GENTL_GIGE_DEVICE:
            nPacketSize = cam.MV_CC_GetOptimalPacketSize()
            if int(nPacketSize) > 0:
                ret = cam.MV_CC_SetIntValue("GevSCPSPacketSize", nPacketSize)
                if ret != 0:
                    print("Warning: Set Packet Size fail! ret[0x%x]" % ret)
            else:
                print("Warning: Get Packet Size fail! ret[0x%x]" % nPacketSize)

        # Set trigger mode to off
        ret = cam.MV_CC_SetEnumValue("TriggerMode", 0)
        if ret != 0:
            raise Exception("set trigger mode fail! ret[0x%x]" % ret)

        # Start grabbing images
        ret = cam.MV_CC_StartGrabbing()
        if ret != 0:
            raise Exception("start grabbing fail! ret[0x%x]" % ret)

        # Obtained frame information
        stOutFrame = MV_FRAME_OUT()
        memset(byref(stOutFrame), 0, sizeof(stOutFrame))

        # Decode parameters
        stDecodeParam = MV_CC_HB_DECODE_PARAM()
        memset(byref(stDecodeParam), 0, sizeof(stDecodeParam))

        # Reconstruct image parameters
        stReconstructParam = MV_RECONSTRUCT_IMAGE_PARAM()
        memset(byref(stReconstructParam), 0, sizeof(stReconstructParam))

        # Reconstructed image list
        dst_buffer_list = []

        ret = cam.MV_CC_GetImageBuffer(stOutFrame, 20000)
        if ret == 0:
            print("get one frame: Width[%d], Height[%d], nFrameNum[%d]" % (
                stOutFrame.stFrameInfo.nWidth, stOutFrame.stFrameInfo.nHeight, stOutFrame.stFrameInfo.nFrameNum))

            # If the image is in HB format, it should be decoded first
            if stOutFrame.stFrameInfo.enPixelType in HB_format_list:
                # Gets the size of the data packet.
                nDevPayloadSize = c_uint64()
                nMemAlignment = c_uint()
                ret = cam.MV_CC_GetPayloadSize(nDevPayloadSize, nMemAlignment)
                if 0 != ret:
                    raise Exception("Get PayloadSize fail! ret[0x%x]" % ret)
                nPayloadSize = nDevPayloadSize.value
                stDecodeParam.pSrcBuf = stOutFrame.pBufAddr
                stDecodeParam.nSrcLen = stOutFrame.stFrameInfo.nFrameLen
                stDecodeParam.pDstBuf = (c_ubyte * nPayloadSize)()
                stDecodeParam.nDstBufSize = nPayloadSize
                ret = cam.MV_CC_HBDecode(stDecodeParam)
                if ret != 0:
                    cam.MV_CC_FreeImageBuffer(stOutFrame)
                    raise Exception("HB Decode fail! ret[0x%x]" % ret)
                else:
                    stReconstructParam.nWidth = stDecodeParam.nWidth
                    stReconstructParam.nHeight = stDecodeParam.nHeight
                    stReconstructParam.enPixelType = stDecodeParam.enDstPixelType
                    stReconstructParam.pSrcData = stDecodeParam.pDstBuf
                    stReconstructParam.nSrcDataLen = stDecodeParam.nDstBufLen
            else:
                stReconstructParam.nWidth = stOutFrame.stFrameInfo.nWidth
                stReconstructParam.nHeight = stOutFrame.stFrameInfo.nHeight
                stReconstructParam.enPixelType = stOutFrame.stFrameInfo.enPixelType
                stReconstructParam.pSrcData = stOutFrame.pBufAddr
                stReconstructParam.nSrcDataLen = stOutFrame.stFrameInfo.nFrameLen

            stReconstructParam.nExposureNum = exposure_num
            stReconstructParam.enReconstructMethod = MV_SPLIT_BY_LINE

            dst_buffer_len = int(stReconstructParam.nSrcDataLen/exposure_num)
            for i in range(exposure_num):
                dst_buffer = (c_ubyte * dst_buffer_len)()
                dst_buffer_list.append(dst_buffer)
                stReconstructParam.stDstBufList[i].pBuf = dst_buffer_list[i]
                stReconstructParam.stDstBufList[i].nBufSize = dst_buffer_len

            # Image reconstruction
            ret = cam.MV_CC_ReconstructImage(stReconstructParam)
            if ret != 0:
                cam.MV_CC_FreeImageBuffer(stOutFrame)
                raise Exception("MV_CC_ReconstructImage fail! ret[0x%x]" % ret)
            else:
                print("Reconstruct image success")

            # Save image to file
            file_name = "Image_w%d_h%d_fn%d.bmp" % (stReconstructParam.nWidth, stReconstructParam.nHeight,
                                                    stOutFrame.stFrameInfo.nFrameNum)
            c_file_path = file_name.encode('ascii')
            stSaveParam = MV_SAVE_IMAGE_TO_FILE_PARAM_EX()
            stSaveParam.enPixelType = stReconstructParam.enPixelType  # The image pixel format
            stSaveParam.nWidth = stReconstructParam.nWidth  # The image width
            stSaveParam.nHeight = 0  # The image height
            stSaveParam.nDataLen = 0

            # The redundant rows lines will be discarded during image splitting, so the height and data length of the stored image should be recalculated.
            sub_len = stReconstructParam.stDstBufList[i].nBufLen
            for i in range(exposure_num):
                stSaveParam.nDataLen = stSaveParam.nDataLen + sub_len
                stSaveParam.nHeight = stSaveParam.nHeight + stReconstructParam.stDstBufList[i].nHeight

            img_buff = (c_ubyte * stSaveParam.nDataLen)()
            for i in range(exposure_num):
                ctypes.memmove(ctypes.addressof(img_buff)+i*sub_len, stReconstructParam.stDstBufList[i].pBuf, sub_len)

            stSaveParam.pData = img_buff
            stSaveParam.enImageType = MV_Image_Bmp  # The image format for saving
            stSaveParam.pcImagePath = create_string_buffer(c_file_path)
            stSaveParam.iMethodValue = 1
            ret = cam.MV_CC_SaveImageToFileEx(stSaveParam)
            if ret != 0:
                print("Save stitched image fail! ret[0x%x]" % ret)
            else:
                print("Save stitched image success")
            cam.MV_CC_FreeImageBuffer(stOutFrame)
        else:
            raise Exception("no data[0x%x]" % ret)

        # Stop grabbing images
        ret = cam.MV_CC_StopGrabbing()
        if ret != 0:
            raise Exception("stop grabbing fail! ret[0x%x]" % ret)

        # Turn off the device
        ret = cam.MV_CC_CloseDevice()
        if ret != 0:
            raise Exception("close device fail! ret[0x%x]" % ret)

        # Destroy the handle
        cam.MV_CC_DestroyHandle()

    except Exception as e:
        print(e)
        cam.MV_CC_CloseDevice()
        cam.MV_CC_DestroyHandle()
    finally:
        # Release SDK resources
        MvCamera.MV_CC_Finalize()